// #include <iostream>
// #include <stdexcept>
// using namespace std;

// class MyException : public runtime_error {
// public:
//     MyException(const string& msg) : runtime_error(msg) {}
//     virtual string details() const { 
//         return "Additional info: " + string(what());
//     }
// };

// class SpecificException : public MyException {
// public:
//     SpecificException(const string& msg) : MyException(msg) {}
//     string details() const override {
//         return "Specific details: " + string(what());
//     }
// };

// int main() {
//     try {
//         throw MyException("Something went wrong!");
//     } catch (const MyException& e) { // 基类引用捕获
//         cerr << e.details() << endl; // 输出多态信息
//     }
//     return 0;
// }

// #include<iostream>
// using namespace std;

// class Base {
// public:
//     virtual ~Base() {} // 必须包含虚函数
// };

// class Derived : public Base {
// public:
//     void specificMethod() { /* 派生类特有方法 */ }
// };

// void process(Base* base) {
//     // 尝试转换为Derived类型
//     Derived* derived = dynamic_cast<Derived*>(base);
//     if (derived) { // 检查是否转换成功
//         cout<<"转型成功"<<endl;
//     } else {
//         cerr << "转换失败：非Derived类型" << endl;
//     }
// }

// int main()
// {
//     Base* pd = new Derived();
//     process(pd);
//     Base* pb = new Base();
//     process(pb);
//     return 0;
// }

// #include <iostream>
// #include <mutex>
// #include <thread>
// using namespace std;
// class Singleton
// {
// public:
//     static Singleton* GetInstance() 
//     {
//     // 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
//         if (nullptr == m_pInstance) 
//         {
//             m_mtx.lock();
//             if (nullptr == m_pInstance) 
//             {
//                 m_pInstance = new Singleton();
//             }
//             m_mtx.unlock();
//         }
//         return m_pInstance;
//     }
//     // 实现一个内嵌垃圾回收类
//     class CGarbo {
//     public:
//         ~CGarbo()
//         {
//             if (Singleton::m_pInstance)
//                 delete Singleton::m_pInstance;
//         }
//     };
//     // 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
//     static CGarbo Garbo;
// private:
//     // 构造函数私有
//     Singleton(){};
//     // 防拷贝
//     Singleton(Singleton const&);
//     Singleton& operator=(Singleton const&);
//     static Singleton* m_pInstance; // 单例对象指针
//     static mutex m_mtx; //互斥锁
// };

// Singleton* Singleton::m_pInstance = nullptr;
// Singleton::CGarbo Garbo;
// mutex Singleton::m_mtx;

// int main()
// {
//     thread t1([]{cout << &Singleton::GetInstance() << endl; });
//     thread t2([]{cout << &Singleton::GetInstance() << endl; });
//     t1.join();
//     t2.join();
//     cout << &Singleton::GetInstance() << endl;
//     cout << &Singleton::GetInstance() << endl;
//     return 0;
// }

// #include<algorithm>
// #include<iostream>
// #include<cstring>
// using std::cout;
// using std::endl;
// namespace ddsm
// {
//     class string
//     {
//     public:
//         void swap(ddsm::string& s)
//         {
//             std::swap(_size,s._size);
//             std::swap(_capacity,s._capacity);
//             std::swap(_array,s._array);
//         }
//         //迭代器设计
//         using iterator = char*;
//         using const_iterator = const char*;
//         iterator begin()
//         {
//             return _array;
//         }
//         iterator end()
//         {
//             return _array + _size;
//         }
//         const_iterator begin() const
//         {
//             return _array;
//         }
//         const_iterator end() const
//         {
//             return _array + _size;
//         }
//         //构造函数
//         string(const char* str = "")//default给空串
//             :_size(strlen(str))
//             ,_capacity(_size)
//             ,_array(new char[_size + 1])
//         {
//             strcpy(_array,str);
//         }
//         //拷贝构造现代写法
//         string(const ddsm::string& s)
//             :_array(nullptr)
//         {
//             ddsm::string tem(s._array);//复用构造函数
//             ddsm::string::swap(tem);
//         }
//         //复用拷贝构造
//         ddsm::string& operator=(string tem)//局部对象，出作用域析构
//         {
//             swap(tem);
//             return *this;
//         }
//         void Print()
//         {
//             for(int i = 0;i < _size;++i)
//             {
//                 cout<<*(_array+i);
//             }
//             cout<<endl;
//         }
//         //保留一定长度n，只增不减
//         void reserve(int n)
//         {
//             if(n > _capacity)
//             {
//                 char* tem = new char[n + 1];
//                 strcpy(tem,_str);
//                 delete[] _str;
//                 _str = tem;
//                 _capacity = n;
//                 //reserve不改变size
//             }
//         }
//         void resize(int n)
//         {

//         }
//         ~string()
//         {
//             if(_array)
//                 delete[] _array;
//             _capacity = _size = 0;
//             _array = nullptr;
//         }
//     private:
//         size_t _size;//实际存储字符串的长度,这个长度不包含'\0'
//         size_t _capacity;//实际开辟的空间的长度
//         char* _array;//指向堆区空间的指针
//     };
// };

int main()
{
    ddsm::string str1("hello");
    ddsm::string str2(str1);
    ddsm::string str3;
    str3 = str2;
    str1.Print();
    str2.Print();
    str3.Print();

    return 0;
}